home *** CD-ROM | disk | FTP | other *** search
/ Champak 43 / Vol 43.iso / games / phit.swf / scripts / __Packages / MathUtil.as < prev    next >
Encoding:
Text File  |  2007-07-13  |  3.9 KB  |  168 lines
  1. class MathUtil
  2. {
  3.    function MathUtil()
  4.    {
  5.    }
  6.    static function RandRange(min, max)
  7.    {
  8.       return min + Math.random() * (max - min);
  9.    }
  10.    static function RadiansToDegrees(radians)
  11.    {
  12.       return radians / 3.141592653589793 * 180;
  13.    }
  14.    static function DegreesToRadians(degrees)
  15.    {
  16.       return degrees / 180 * 3.141592653589793;
  17.    }
  18.    static function Clamp(x, min, max)
  19.    {
  20.       return Math.max(Math.min(x,max),min);
  21.    }
  22.    static function Wrap(x, min, max)
  23.    {
  24.       var _loc1_ = (x - min) % (max - min);
  25.       return _loc1_ >= 0 ? min + _loc1_ : max + _loc1_;
  26.    }
  27.    static function Sign(x)
  28.    {
  29.       return x <= 0 ? (x >= 0 ? 0 : -1) : 1;
  30.    }
  31.    static function SignNoZero(x)
  32.    {
  33.       return x < 0 ? -1 : 1;
  34.    }
  35.    static function MaxAbs(x, y)
  36.    {
  37.       if(Math.abs(x) > Math.abs(y))
  38.       {
  39.          return x;
  40.       }
  41.       return y;
  42.    }
  43.    static function MinAbs(x, y)
  44.    {
  45.       if(Math.abs(x) < Math.abs(y))
  46.       {
  47.          return x;
  48.       }
  49.       return y;
  50.    }
  51.    static function GetNormalizedAngle(angle)
  52.    {
  53.       return MathUtil.Wrap(angle,-180,180);
  54.    }
  55.    static function AngleDelta(a1, a2)
  56.    {
  57.       return MathUtil.GetNormalizedAngle(a1 - a2);
  58.    }
  59.    static function Lerp(a, b, alpha)
  60.    {
  61.       return a + (b - a) * alpha;
  62.    }
  63.    static function AngleLerp(a, b, alpha)
  64.    {
  65.       return MathUtil.GetNormalizedAngle(a + MathUtil.AngleDelta(b,a) * alpha);
  66.    }
  67.    static function VectorLerp(a, b, alpha)
  68.    {
  69.       return a.GetAdd(b.GetSubtract(a).GetMultiplyScalar(alpha));
  70.    }
  71.    static function RGBtoHSV(r, g, b)
  72.    {
  73.       r /= 255;
  74.       g /= 255;
  75.       b /= 255;
  76.       var _loc1_ = new Object();
  77.       var _loc7_ = undefined;
  78.       var _loc2_ = undefined;
  79.       var _loc4_ = undefined;
  80.       _loc7_ = Math.min(r,Math.min(g,b));
  81.       _loc2_ = Math.max(r,Math.max(g,b));
  82.       _loc1_.v = _loc2_;
  83.       _loc4_ = _loc2_ - _loc7_;
  84.       if(_loc2_ != 0)
  85.       {
  86.          _loc1_.s = _loc4_ / _loc2_;
  87.          if(r == _loc2_)
  88.          {
  89.             _loc1_.h = (g - b) / _loc4_;
  90.          }
  91.          else if(g == _loc2_)
  92.          {
  93.             _loc1_.h = 2 + (b - r) / _loc4_;
  94.          }
  95.          else
  96.          {
  97.             _loc1_.h = 4 + (r - g) / _loc4_;
  98.          }
  99.          _loc1_.h *= 60;
  100.          if(_loc1_.h < 0)
  101.          {
  102.             _loc1_.h += 360;
  103.          }
  104.          return _loc1_;
  105.       }
  106.       _loc1_.s = 0;
  107.       _loc1_.h = undefined;
  108.       return _loc1_;
  109.    }
  110.    static function HSVtoRGB(h, s, v)
  111.    {
  112.       h = MathUtil.Wrap(h,0,360);
  113.       var _loc1_ = new Object();
  114.       var _loc8_ = undefined;
  115.       var _loc9_ = undefined;
  116.       var _loc3_ = undefined;
  117.       var _loc5_ = undefined;
  118.       var _loc4_ = undefined;
  119.       if(s == 0)
  120.       {
  121.          _loc1_.r = _loc1_.g = _loc1_.b = v * 255;
  122.          return _loc1_;
  123.       }
  124.       h /= 60;
  125.       _loc8_ = Math.floor(h);
  126.       _loc9_ = h - _loc8_;
  127.       _loc3_ = v * (1 - s);
  128.       _loc5_ = v * (1 - s * _loc9_);
  129.       _loc4_ = v * (1 - s * (1 - _loc9_));
  130.       switch(_loc8_)
  131.       {
  132.          case 0:
  133.             _loc1_.r = v;
  134.             _loc1_.g = _loc4_;
  135.             _loc1_.b = _loc3_;
  136.             break;
  137.          case 1:
  138.             _loc1_.r = _loc5_;
  139.             _loc1_.g = v;
  140.             _loc1_.b = _loc3_;
  141.             break;
  142.          case 2:
  143.             _loc1_.r = _loc3_;
  144.             _loc1_.g = v;
  145.             _loc1_.b = _loc4_;
  146.             break;
  147.          case 3:
  148.             _loc1_.r = _loc3_;
  149.             _loc1_.g = _loc5_;
  150.             _loc1_.b = v;
  151.             break;
  152.          case 4:
  153.             _loc1_.r = _loc4_;
  154.             _loc1_.g = _loc3_;
  155.             _loc1_.b = v;
  156.             break;
  157.          default:
  158.             _loc1_.r = v;
  159.             _loc1_.g = _loc3_;
  160.             _loc1_.b = _loc5_;
  161.       }
  162.       _loc1_.r *= 255;
  163.       _loc1_.g *= 255;
  164.       _loc1_.b *= 255;
  165.       return _loc1_;
  166.    }
  167. }
  168.